import { Op } from 'sequelize';
import DictType from '@/models/system/dict-type.model';
import DictData from '@/models/system/dict-data.model';
import { getLogger } from '@/utils/logger';
import ExcelUtil, { ExcelField } from '@/utils/excel/excel.util';
import cacheUtils from '@/utils/cache/cache.util';

// sys_dict 缓存 key 前缀
const SYS_DICT_PREFIX = 'sys_dict:';

const logger = getLogger("dict-service", {
  console: false,
});
const consoleLogger = getLogger("dict-service");

class DictService {
  /**
   * 根据字典类型查询字典数据（带redis缓存）
   * @param dictType 字典类型
   */
  async selectDictDataByType(dictType: string) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`根据字典类型查询字典数据: dictType=${dictType}`);
      
      // 先查缓存
      const cacheRes = await cacheUtils.get(`${SYS_DICT_PREFIX}${dictType}`);
      if (cacheRes.success && cacheRes.data) {
        logger.info(`字典类型 ${dictType} 命中缓存`);
        return cacheRes.data;
      }
      
      // 检查字典类型是否存在且为正常状态
      const type = await DictType.findOne({
        where: { dictType, status: '0' }
      });
      
      if (!type) {
        logger.warn(`字典类型 ${dictType} 不存在或已停用`);
        return [];
      }
      
      // 查询字典数据
      const dictDataList = await DictData.findAll({
        where: { dictType, status: '0' },
        order: [['dictSort', 'ASC']]
      });
      
      // 写入缓存（1小时）
      await cacheUtils.set(`${SYS_DICT_PREFIX}${dictType}`, dictDataList, 3600);
      
      // 记录查询结果
      logger.info(`字典数据查询完成: dictType=${dictType}, 数据数量=${dictDataList.length}`);
      
      return dictDataList;
    } catch (error) {
      consoleLogger.error(`查询字典数据失败: ${error instanceof Error ? error.message : String(error)}`);
      return [];
    }
  }
  
  /**
   * 查询字典类型列表
   * @param params 查询参数
   */
  async selectDictTypeList(params: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`查询字典类型列表: ${JSON.stringify(params)}`);
      
      const { pageNum = 1, pageSize = 10, dictName, dictType, status, beginTime, endTime } = params;
      
      // 构建查询条件
      const where: any = {};
      
      if (dictName) {
        where.dictName = { [Op.like]: `%${dictName}%` };
      }
      
      if (dictType) {
        where.dictType = { [Op.like]: `%${dictType}%` };
      }
      
      if (status) {
        where.status = status;
      }
      
      // 创建时间范围
      if (beginTime && endTime) {
        where.createTime = {
          [Op.between]: [beginTime, endTime]
        };
      }
      
      // 执行分页查询
      const { count, rows } = await DictType.findAndCountAll({
        where,
        offset: (pageNum - 1) * pageSize,
        limit: parseInt(pageSize as string),
        order: [
          ['createTime', 'DESC']
        ]
      });
      
      // 记录查询结果
      logger.info(`字典类型列表查询完成: 总数=${count}, 页码=${pageNum}, 每页=${pageSize}`);
      
      return {
        total: count,
        rows,
        pageNum,
        pageSize
      };
    } catch (error) {
      consoleLogger.error(`查询字典类型列表失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('查询字典类型列表失败');
    }
  }
  
  /**
   * 查询字典数据列表
   * @param params 查询参数
   */
  async selectDictDataList(params: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`查询字典数据列表: ${JSON.stringify(params)}`);
      
      const { pageNum = 1, pageSize = 10, dictType, dictLabel, status, beginTime, endTime } = params;
      
      // 构建查询条件
      const where: any = {};
      
      if (dictType) {
        where.dictType = dictType;
      }
      
      if (dictLabel) {
        where.dictLabel = { [Op.like]: `%${dictLabel}%` };
      }
      
      if (status) {
        where.status = status;
      }
      
      // 创建时间范围
      if (beginTime && endTime) {
        where.createTime = {
          [Op.between]: [beginTime, endTime]
        };
      }
      
      // 执行分页查询
      const { count, rows } = await DictData.findAndCountAll({
        where,
        offset: (pageNum - 1) * pageSize,
        limit: parseInt(pageSize as string),
        order: [
          ['dictSort', 'ASC']
        ]
      });
      
      // 记录查询结果
      logger.info(`字典数据列表查询完成: 总数=${count}, 页码=${pageNum}, 每页=${pageSize}`);
      
      return {
        total: count,
        rows,
        pageNum,
        pageSize
      };
    } catch (error) {
      consoleLogger.error(`查询字典数据列表失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('查询字典数据列表失败');
    }
  }
  
  /**
   * 根据字典类型ID查询详细信息
   * @param dictId 字典类型ID
   */
  async selectDictTypeById(dictId: number) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`根据ID查询字典类型: dictId=${dictId}`);
      
      // 检查dictId是否为有效数字
      if (isNaN(dictId)) {
        consoleLogger.error(`根据ID查询字典类型失败: dictId "${dictId}" 不是有效的数字`);
        throw new Error('无效的字典类型ID');
      }
      
      const dictType = await DictType.findByPk(dictId);
      
      // 记录查询结果
      if (dictType) {
        logger.info(`字典类型查询成功: dictId=${dictId}, dictName=${dictType.dictName}`);
      } else {
        logger.info(`未找到字典类型: dictId=${dictId}`);
      }
      
      return dictType;
    } catch (error) {
      consoleLogger.error(`查询字典类型详细信息失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('查询字典类型详细信息失败');
    }
  }
  
  /**
   * 根据字典数据ID查询详细信息
   * @param dictCode 字典数据ID
   */
  async selectDictDataById(dictCode: number) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`根据ID查询字典数据: dictCode=${dictCode}`);
      
      // 检查dictCode是否为有效数字
      if (isNaN(dictCode)) {
        consoleLogger.error(`根据ID查询字典数据失败: dictCode "${dictCode}" 不是有效的数字`);
        throw new Error('无效的字典数据ID');
      }
      
      const dictData = await DictData.findByPk(dictCode);
      
      // 记录查询结果
      if (dictData) {
        logger.info(`字典数据查询成功: dictCode=${dictCode}, dictLabel=${dictData.dictLabel}`);
      } else {
        logger.info(`未找到字典数据: dictCode=${dictCode}`);
      }
      
      return dictData;
    } catch (error) {
      consoleLogger.error(`查询字典数据详细信息失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('查询字典数据详细信息失败');
    }
  }
  
  /**
   * 根据字典类型删除字典数据
   * @param dictType 字典类型
   */
  async deleteDictDataByType(dictType: string) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`根据类型删除字典数据: dictType=${dictType}`);
      
      if (!dictType) {
        consoleLogger.error('根据类型删除字典数据失败: 字典类型参数为空');
        throw new Error('字典类型参数不能为空');
      }
      
      const result = await DictData.destroy({
        where: { dictType }
      });
      
      // 记录操作结果
      logger.info(`字典数据删除完成: dictType=${dictType}, 影响行数=${result}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`删除字典数据失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('删除字典数据失败');
    }
  }

  /**
   * 校验字典类型唯一
   * @param dictType 字典类型
   * @param dictId 字典类型ID（修改时排除自身）
   */
  async checkDictTypeUnique(dictType: string, dictId?: number) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`校验字典类型唯一性: dictType=${dictType}, dictId=${dictId || '未提供'}`);
      
      if (!dictType) {
        logger.warn('校验字典类型唯一性: 字典类型参数为空');
        return false;
      }
      
      const where: any = { dictType };
      if (dictId) where.dictId = { [Op.ne]: dictId };
      
      const count = await DictType.count({ where });
      const isUnique = count === 0;
      
      // 记录查询结果
      logger.info(`字典类型唯一性校验完成: dictType=${dictType}, 是否唯一=${isUnique}`);
      
      return isUnique;
    } catch (error) {
      consoleLogger.error(`校验字典类型唯一性失败: ${error instanceof Error ? error.message : String(error)}`);
      // 发生错误时，返回false以确保安全
      return false;
    }
  }

  /**
   * 新增字典类型
   * @param dictType 字典类型对象
   */
  async insertDictType(dictType: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`新增字典类型: dictName=${dictType.dictName}, dictType=${dictType.dictType}`);
      
      if (!dictType.dictType || !dictType.dictName) {
        consoleLogger.error('新增字典类型失败: 参数不完整');
        throw new Error('字典类型名称和类型值不能为空');
      }
      
      const result = await DictType.create(dictType);
      
      // 记录操作结果
      logger.info(`字典类型新增成功: dictId=${result.dictId}, dictName=${result.dictName}`);
      
      // 新增类型后无需立即写缓存，等首次查询时写入
      return result;
    } catch (error) {
      consoleLogger.error(`新增字典类型失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('新增字典类型失败');
    }
  }

  /**
   * 修改字典类型
   * @param dictType 字典类型对象
   */
  async updateDictType(dictType: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`修改字典类型: dictId=${dictType.dictId}, dictName=${dictType.dictName}, dictType=${dictType.dictType}`);
      
      // 检查dictId是否有效
      if (isNaN(dictType.dictId)) {
        consoleLogger.error(`修改字典类型失败: dictId "${dictType.dictId}" 不是有效的数字`);
        throw new Error('无效的字典类型ID');
      }
      
      const exist = await DictType.findByPk(dictType.dictId);
      if (!exist) {
        logger.warn(`字典类型不存在: dictId=${dictType.dictId}`);
        throw new Error('字典类型不存在');
      }
      
      const oldDictType = exist.dictType; // 记录旧的类型值
      const result = await exist.update(dictType);
      
      // 类型值变更时，删除旧缓存
      if (oldDictType !== dictType.dictType) {
        logger.info(`字典类型值已变更: ${oldDictType} -> ${dictType.dictType}, 删除旧缓存`);
        await this.delSysDictCache(oldDictType);
      }
      
      // 删除新类型缓存，等下次查询时写入
      await this.delSysDictCache(dictType.dictType);
      
      // 记录操作结果
      logger.info(`字典类型修改完成: dictId=${dictType.dictId}, dictName=${dictType.dictName}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`修改字典类型失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('修改字典类型失败');
    }
  }

  /**
   * 删除字典类型
   * @param dictId 字典类型ID
   */
  async deleteDictTypeById(dictId: number) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`删除字典类型: dictId=${dictId}`);
      
      // 检查dictId是否有效
      if (isNaN(dictId)) {
        consoleLogger.error(`删除字典类型失败: dictId "${dictId}" 不是有效的数字`);
        throw new Error('无效的字典类型ID');
      }
      
      // 查找类型名
      const type = await DictType.findByPk(dictId);
      if (!type) {
        logger.warn(`未找到字典类型: dictId=${dictId}`);
        throw new Error('未找到要删除的字典类型');
      }
      
      const result = await DictType.destroy({ where: { dictId } });
      
      if (type.dictType) {
        // 删除缓存
        logger.info(`删除字典类型缓存: dictType=${type.dictType}`);
        await this.delSysDictCache(type.dictType);
      }
      
      // 记录操作结果
      logger.info(`字典类型删除完成: dictId=${dictId}, dictType=${type.dictType}, 影响行数=${result}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`删除字典类型失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('删除字典类型失败');
    }
  }

  /**
   * 新增字典数据
   * @param dictData 字典数据对象
   */
  async insertDictData(dictData: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`新增字典数据: dictType=${dictData.dictType}, dictLabel=${dictData.dictLabel}`);
      
      if (!dictData.dictType || !dictData.dictLabel || !dictData.dictValue) {
        consoleLogger.error('新增字典数据失败: 参数不完整');
        throw new Error('字典类型、标签和值不能为空');
      }
      
      const result = await DictData.create(dictData);
      
      // 新增数据后，删除对应类型缓存，等下次查询时写入
      if (dictData.dictType) {
        logger.info(`删除字典类型缓存: dictType=${dictData.dictType}`);
        await this.delSysDictCache(dictData.dictType);
      }
      
      // 记录操作结果
      logger.info(`字典数据新增成功: dictCode=${result.dictCode}, dictLabel=${result.dictLabel}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`新增字典数据失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('新增字典数据失败');
    }
  }

  /**
   * 修改字典数据
   * @param dictData 字典数据对象
   */
  async updateDictData(dictData: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`修改字典数据: dictCode=${dictData.dictCode}, dictLabel=${dictData.dictLabel}`);
      
      // 检查dictCode是否有效
      if (isNaN(dictData.dictCode)) {
        consoleLogger.error(`修改字典数据失败: dictCode "${dictData.dictCode}" 不是有效的数字`);
        throw new Error('无效的字典数据ID');
      }
      
      const exist = await DictData.findByPk(dictData.dictCode);
      if (!exist) {
        logger.warn(`字典数据不存在: dictCode=${dictData.dictCode}`);
        throw new Error('字典数据不存在');
      }
      
      const result = await exist.update(dictData);
      
      // 数据变更后，删除对应类型缓存，等下次查询时写入
      if (dictData.dictType) {
        logger.info(`删除字典类型缓存: dictType=${dictData.dictType}`);
        await this.delSysDictCache(dictData.dictType);
      }
      
      // 记录操作结果
      logger.info(`字典数据修改完成: dictCode=${dictData.dictCode}, dictLabel=${dictData.dictLabel}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`修改字典数据失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('修改字典数据失败');
    }
  }

  /**
   * 删除字典数据
   * @param dictCode 字典数据ID
   */
  async deleteDictDataById(dictCode: number) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`删除字典数据: dictCode=${dictCode}`);
      
      // 检查dictCode是否有效
      if (isNaN(dictCode)) {
        consoleLogger.error(`删除字典数据失败: dictCode "${dictCode}" 不是有效的数字`);
        throw new Error('无效的字典数据ID');
      }
      
      // 查找类型名
      const data = await DictData.findByPk(dictCode);
      if (!data) {
        logger.warn(`未找到字典数据: dictCode=${dictCode}`);
        throw new Error('未找到要删除的字典数据');
      }
      
      const result = await DictData.destroy({ where: { dictCode } });
      
      if (data.dictType) {
        logger.info(`删除字典类型缓存: dictType=${data.dictType}`);
        await this.delSysDictCache(data.dictType);
      }
      
      // 记录操作结果
      logger.info(`字典数据删除完成: dictCode=${dictCode}, dictType=${data.dictType}, 影响行数=${result}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`删除字典数据失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('删除字典数据失败');
    }
  }

  /**
   * 获取字典类型下拉选择框数据
   */
  async selectDictTypeOptions() {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info('查询字典类型下拉选项');
      
      const types = await DictType.findAll({
        where: { status: '0' },
        attributes: ['dictId', 'dictName', 'dictType'],
        order: [['dictId', 'ASC']]
      });
      
      // 记录查询结果
      logger.info(`字典类型下拉选项查询完成: 选项数量=${types.length}`);
      
      return types;
    } catch (error) {
      consoleLogger.error(`获取字典类型下拉选项失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('获取字典类型下拉选项失败');
    }
  }

  /**
   * 批量删除字典数据
   * @param dictCodes 字典数据ID数组
   */
  async deleteDictDataByIds(dictCodes: number[]) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`批量删除字典数据: dictCodes=${JSON.stringify(dictCodes)}`);
      
      if (!dictCodes || dictCodes.length === 0) {
        consoleLogger.error('批量删除字典数据失败: 参数为空');
        throw new Error('字典数据ID不能为空');
      }
      
      // 查找所有类型名
      const datas = await DictData.findAll({ where: { dictCode: dictCodes } });
      if (datas.length === 0) {
        logger.warn(`未找到要删除的字典数据: dictCodes=${JSON.stringify(dictCodes)}`);
        throw new Error('未找到要删除的字典数据');
      }
      
      const result = await DictData.destroy({ where: { dictCode: dictCodes } });
      
      // 清除相关缓存
      const dictTypes = new Set<string>();
      for (const data of datas) {
        if (data.dictType) {
          dictTypes.add(data.dictType);
        }
      }
      
      // 删除涉及的所有字典类型缓存
      logger.info(`删除字典类型缓存: dictTypes=${Array.from(dictTypes).join(', ')}`);
      for (const dictType of dictTypes) {
        await this.delSysDictCache(dictType);
      }
      
      // 记录操作结果
      logger.info(`字典数据批量删除完成: 删除项数量=${dictCodes.length}, 影响行数=${result}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`批量删除字典数据失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('批量删除字典数据失败');
    }
  }

  /**
   * 导出字典数据为 Excel Buffer
   * @param params 查询参数
   */
  async exportDictDataToExcel(params: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`导出字典数据Excel: ${JSON.stringify(params)}`);
      
      // 直接使用传入的查询参数，保证与查询接口一致
      const { rows } = await this.selectDictDataList(params);
      
      // 统一格式化数据
      const data = rows.map((row: any) => ({
        ...row.dataValues,
        status: row.status === '0' ? '正常' : '停用',
        createTime: row.createTime ? new Date(row.createTime).toLocaleString() : ''
      }));
      
      // 字段定义
      const columns: ExcelField[] = [
        { header: '字典编码', key: 'dictCode' },
        { header: '字典标签', key: 'dictLabel' },
        { header: '字典键值', key: 'dictValue' },
        { header: '字典类型', key: 'dictType' },
        { header: '样式属性', key: 'cssClass' },
        { header: '显示排序', key: 'dictSort' },
        { header: '状态', key: 'status' },
        { header: '备注', key: 'remark' },
        { header: '创建时间', key: 'createTime' }
      ];
      
      logger.info(`准备导出字典数据: 数据量=${data.length}`);
      
      // 使用 ExcelUtil 工具导出
      const excelBuffer = await ExcelUtil.exportExcel(data, columns, '字典数据');
      
      // 记录操作结果
      logger.info(`字典数据导出Excel完成: 数据量=${data.length}`);
      
      return excelBuffer;
    } catch (error) {
      consoleLogger.error(`导出字典数据为Excel失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('导出字典数据失败');
    }
  }

  /**
   * 删除 sys_dict 缓存
   */
  async delSysDictCache(dictType: string) {
    try {
      // 使用logger记录操作
      logger.debug(`尝试删除字典缓存: dictType=${dictType}`);
      
      const cacheResult = await cacheUtils.del(`${SYS_DICT_PREFIX}${dictType}`);
      
      if (!cacheResult.success) {
        consoleLogger.error(`删除 sys_dict 缓存失败: ${cacheResult.error?.message || cacheResult.error}`);
      } else {
        logger.debug(`字典缓存删除成功: dictType=${dictType}`);
      }
    } catch (error) {
      consoleLogger.error(`删除字典缓存异常: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

  /**
   * 刷新字典缓存（清空所有 sys_dict:xxx 缓存并重新加载）
   */
  async refreshCache() {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info('刷新字典缓存');
      
      // 获取所有 sys_dict:xxx 缓存 key
      const keysResult = await cacheUtils.keys(`${SYS_DICT_PREFIX}*`);
      
      // 清除现有缓存
      if (keysResult.success && keysResult.data && keysResult.data.length > 0) {
        logger.info(`清除现有字典缓存: 缓存键数量=${keysResult.data.length}`);
        await cacheUtils.del(keysResult.data);
      }
      
      // 重新加载所有字典类型到缓存
      const types = await DictType.findAll({ where: { status: '0' } });
      logger.info(`重新加载字典类型到缓存: 总数=${types.length}`);
      
      for (const type of types) {
        const dictType = type.dictType;
        const dictDataList = await DictData.findAll({
          where: { dictType, status: '0' },
          order: [['dictSort', 'ASC']]
        });
        
        // 写入缓存
        await cacheUtils.set(`${SYS_DICT_PREFIX}${dictType}`, dictDataList, 3600);
        logger.debug(`字典类型已缓存: dictType=${dictType}, 数据量=${dictDataList.length}`);
      }
      
      // 记录操作结果
      logger.info(`字典缓存刷新完成: 缓存字典类型数量=${types.length}`);
      
      return true;
    } catch (error) {
      consoleLogger.error(`刷新字典缓存失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('刷新字典缓存失败');
    }
  }

  /**
   * 导出字典类型为 Excel Buffer
   * @param params 查询参数
   */
  async exportDictTypeToExcel(params: any) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`导出字典类型Excel: ${JSON.stringify(params)}`);
      
      // 查询数据（不分页，最大5000条）
      const { rows } = await this.selectDictTypeList({ ...params, pageNum: 1, pageSize: 5000 });
      
      const data = rows.map((row: any) => ({
        ...row.dataValues,
        status: row.status === '0' ? '正常' : '停用',
        createTime: row.createTime ? new Date(row.createTime).toLocaleString() : ''
      }));
      
      const columns: ExcelField[] = [
        { header: '字典主键', key: 'dictId' },
        { header: '字典名称', key: 'dictName' },
        { header: '字典类型', key: 'dictType' },
        { header: '状态', key: 'status' },
        { header: '备注', key: 'remark' },
        { header: '创建时间', key: 'createTime' }
      ];
      
      logger.info(`准备导出字典类型: 数据量=${data.length}`);
      
      const excelBuffer = await ExcelUtil.exportExcel(data, columns, '字典类型');
      
      // 记录操作结果
      logger.info(`字典类型导出Excel完成: 数据量=${data.length}`);
      
      return excelBuffer;
    } catch (error) {
      consoleLogger.error(`导出字典类型为Excel失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('导出字典类型失败');
    }
  }

  /**
   * 批量删除字典类型
   * @param dictIds 字典类型ID数组
   */
  async deleteDictTypeByIds(dictIds: number[]) {
    try {
      // 使用consoleLogger记录操作开始
      consoleLogger.info(`批量删除字典类型: dictIds=${JSON.stringify(dictIds)}`);
      
      if (!dictIds || dictIds.length === 0) {
        consoleLogger.error('批量删除字典类型失败: 参数为空');
        throw new Error('字典类型ID不能为空');
      }
      
      // 查询涉及的字典类型，以便删除缓存
      const types = await DictType.findAll({
        where: { dictId: dictIds },
        attributes: ['dictId', 'dictType']
      });
      
      if (types.length === 0) {
        logger.warn(`未找到要删除的字典类型: dictIds=${JSON.stringify(dictIds)}`);
        throw new Error('未找到要删除的字典类型');
      }
      
      // 执行删除
      const result = await DictType.destroy({ where: { dictId: dictIds } });
      
      // 删除相关缓存
      for (const type of types) {
        if (type.dictType) {
          logger.debug(`删除字典类型缓存: dictType=${type.dictType}`);
          await this.delSysDictCache(type.dictType);
        }
      }
      
      // 记录操作结果
      logger.info(`字典类型批量删除完成: 删除项数量=${dictIds.length}, 影响行数=${result}`);
      
      return result;
    } catch (error) {
      consoleLogger.error(`批量删除字典类型失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('批量删除字典类型失败');
    }
  }
}

export default new DictService(); 
